const express = require('express');
const router = express.Router();
const { messageModel, userModel } = require('../db');
const mongoose = require('mongoose');

// 获取用户的联系人列表 - 放在具体路由之前
router.get('/contacts/:userId', async (req, res) => {
  try {
    let { userId } = req.params;
    console.log('原始用户ID:', userId);

    // 尝试解码用户ID（如果需要的话）
    try {
      userId = decodeURIComponent(userId);
      console.log('解码后的用户ID:', userId);
    } catch (decodeError) {
      console.error('解码用户ID失败:', decodeError);
    }

    // 查找所有用户（除了当前用户）
    const users = await userModel.find({}, '_id username image')
      .lean()
      .exec();

    console.log(`找到 ${users.length} 个用户`);

    // 过滤并格式化用户列表
    const formattedUsers = users
      .filter(user => user._id.toString() !== userId)
      .map(user => ({
        _id: user._id.toString(),
        username: user.username || '未命名用户',
        image: user.image || null
      }));

    console.log(`返回 ${formattedUsers.length} 个联系人`);
    return res.json(formattedUsers);

  } catch (error) {
    console.error('获取联系人列表失败:', error);
    return res.status(500).json({ 
      message: '获取联系人列表失败', 
      error: error.message,
      details: error.stack
    });
  }
});

// 获取两个用户之间的聊天记录
router.get('/chat/:userId/:targetId', async (req, res) => {
  try {
    const { userId, targetId } = req.params;
    
    if (!mongoose.Types.ObjectId.isValid(userId) || !mongoose.Types.ObjectId.isValid(targetId)) {
      return res.status(400).json({ message: '无效的用户ID格式' });
    }

    const messages = await messageModel.find({
      $or: [
        { from: userId, to: targetId },
        { from: targetId, to: userId }
      ]
    })
    .sort({ timestamp: 1 })
    .lean()
    .exec();

    res.json(messages);
  } catch (error) {
    console.error('获取聊天记录失败:', error);
    res.status(500).json({ message: '获取聊天记录失败', error: error.message });
  }
});

// 发送新消息
router.post('/', async (req, res) => {
  try {
    const { from, to, content } = req.body;
    
    if (!mongoose.Types.ObjectId.isValid(from) || !mongoose.Types.ObjectId.isValid(to)) {
      return res.status(400).json({ message: '无效的用户ID格式' });
    }

    // 创建新消息
    const newMessage = await messageModel.create({
      from,
      to,
      content,
      timestamp: new Date(),
      isRead: false
    });

    // 更新接收者的未读消息计数
    await userModel.findByIdAndUpdate(
      to,
      {
        $inc: { [`unreadMessages.${from}`]: 1 }
      }
    );

    res.status(201).json(newMessage);
  } catch (error) {
    console.error('发送消息失败:', error);
    res.status(500).json({ message: '发送消息失败', error: error.message });
  }
});

// 标记消息为已读
router.post('/read', async (req, res) => {
  try {
    const { from, to } = req.body;

    if (!mongoose.Types.ObjectId.isValid(from) || !mongoose.Types.ObjectId.isValid(to)) {
      return res.status(400).json({ message: '无效的用户ID格式' });
    }

    // 将所有未读消息标记为已读
    await messageModel.updateMany(
      { from, to, isRead: false },
      { isRead: true }
    );

    // 重置未读消息计数
    await userModel.findByIdAndUpdate(
      to,
      {
        $set: { [`unreadMessages.${from}`]: 0 }
      }
    );

    res.json({ message: '消息已标记为已读' });
  } catch (error) {
    console.error('标记已读失败:', error);
    res.status(500).json({ message: '标记已读失败', error: error.message });
  }
});

module.exports = router; 